﻿#ifndef PST_PIPELINEMANAGER_H
#define PST_PIPELINEMANAGER_H

#include <vector>
#include <algorithm>
#include <cstdlib>
#include <QObject>
#include <sstream>

#include "VtkFilterAdapter.h"

namespace pst
{
    struct FilterEntry
    {
        std::string id;     // 唯一标识符，例如 "cutter_0", "cutter_1"
        IVtkFilter* filter; // 具体过滤器对象

        FilterEntry(const std::string& id_, IVtkFilter* filter_)
            : id(id_), filter(filter_)
        {
        }
    };

    // -----------------------------------------------------------------------------
    // 3. 管道管理器，支持动态添加、删除、插入、交换、清除以及改用指针进行过滤器操作  
    //    并在数据处理时根据每个过滤器的开关判断是否调用当前节点处理  
    // -----------------------------------------------------------------------------

    class PipelineManager : public QObject
    {
        Q_OBJECT

    public:
        PipelineManager(QObject* parent = nullptr) : QObject(parent) {}

        ~PipelineManager()
        {
            ClearFilters();
        }

        // 添加过滤器，使用唯一标识符避免重复添加
        void AddFilter(const std::string& id, IVtkFilter* filter)
        {
            if (HasFilterByID(id))
            {
                std::cout << "Filter with ID '" << id << "' already exists in the pipeline." << std::endl;
                return; // 如果已经存在，直接返回
            }
            filters.emplace_back(id, filter);
        }

        // 判断是否存在某个过滤器（通过 ID）
        bool HasFilterByID(const std::string& id) const
        {
            return std::any_of(filters.begin(), filters.end(), [&id](const FilterEntry& entry) {
                return entry.id == id;
                });
        }

        // 判断某个过滤器实例是否存在（通过指针匹配）
        bool HasFilterByInstance(IVtkFilter* filter) const
        {
            return std::any_of(filters.begin(), filters.end(), [&filter](const FilterEntry& entry) {
                return entry.filter == filter;
                });
        }

        // 删除过滤器（通过 ID）
        bool RemoveFilterByID(const std::string& id)
        {
            auto it = std::find_if(filters.begin(), filters.end(), [&id](const FilterEntry& entry) {
                return entry.id == id;
                });
            if (it != filters.end())
            {
                delete it->filter; // 释放内存
                filters.erase(it); // 移除条目
                return true;
            }
            return false;
        }

        // 删除过滤器（通过实例）
        bool RemoveFilterByInstance(IVtkFilter* filter)
        {
            auto it = std::find_if(filters.begin(), filters.end(), [&filter](const FilterEntry& entry) {
                return entry.filter == filter;
                });
            if (it != filters.end())
            {
                delete it->filter; // 释放内存
                filters.erase(it); // 移除条目
                return true;
            }
            return false;
        }

        // 清除所有过滤器
        void ClearFilters()
        {
            for (auto& entry : filters)
            {
                delete entry.filter;
            }
            filters.clear();
        }

        // 执行数据处理
        vtkDataObject* Process(vtkDataObject* inputData)
        {
            vtkDataObject* currentData = inputData;
            for (auto& entry : filters)
            {
                if (entry.filter->isEnabled())
                {
                    entry.filter->setInput(currentData);
                    entry.filter->update();
                    currentData = entry.filter->getOutput();
                }
            }
            return currentData;
        }

    private:
        std::vector<FilterEntry> filters; // 有序过滤器列表
    };
}

#endif
